home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 3: Developer Tools / Linux Cubed Series 3 - Developer Tools.iso / devel / lang / lisp / guile-ii.src / guile-ii / guile-src / guile-docs / user / scm.info-5 < prev    next >
Encoding:
GNU Info File  |  1995-06-08  |  42.2 KB  |  912 lines
  1. This is Info file scm.info, produced by Makeinfo-1.55 from the input
  2. file scm.texi.
  3.  
  4. 
  5. File: scm.info,  Node: Evaluation,  Prev: Continuations,  Up: Operations
  6.  
  7. Evaluation
  8. ----------
  9.  
  10.  - Variable: symhash
  11.      Top level symbol values are stored in the `symhash' table.
  12.      `symhash' is an array of lists of ISYMs and pairs of symbols and
  13.      values.
  14.  
  15.  - Immediate: ILOC
  16.      Whenever a symbol's value is found in the local environment the
  17.      pointer to the symbol in the code is replaced with an immediate
  18.      object (ILOC) which specifies how many environment frames down and
  19.      how far in to go for the value.  When this immediate object is
  20.      subsequently encountered, the value can be retrieved quickly.
  21.  
  22.  - Immediate: GLOC
  23.      Pointers to symbols not defined in local environments are changed
  24.      to one plus the value cell address in symhash.  This incremented
  25.      pointer is called a GLOC.  The low order bit is normally reserved
  26.      for GCmark; But, since references to variables in the code always
  27.      occur in the `CAR' position and the GCmark is in the `CDR', there
  28.      is no conflict.
  29.  
  30. If the compile FLAG `CAUTIOUS' is #defined then the number of arguments
  31. is always checked for application of closures.  If the compile FLAG
  32. `RECKLESS' is #defined then they are not checked.  Otherwise, number of
  33. argument checks for closures are made only when the function position
  34. (whose value is the closure) of a combination is not an ILOC or GLOC.
  35. When the function position of a combination is a symbol it will be
  36. checked only the first time it is evaluated because it will then be
  37. replaced with an ILOC or GLOC.
  38.  
  39.  - Macro: EVAL EXPRESSION ENV
  40.  - Macro: SIDEVAL EXPRESSION ENV
  41.      `EVAL' Returns the result of evaluating EXPRESSION in ENV.
  42.      `SIDEVAL' evaluates EXPRESSION in ENV when the value of the
  43.      expression is not used.
  44.  
  45.      Both of these macros alter the list structure of EXPRESSION as it
  46.      is memoized and hence should be used only when it is known that
  47.      EXPRESSION will not be referenced again.  The C function `eval' is
  48.      safe from this problem.
  49.  
  50.  - Function: SCM eval (SCM EXPRESSION)
  51.      Returns the result of evaluating EXPRESSION in the top-level
  52.      environment.  `eval' copies `expression' so that memoization does
  53.      not modify `expression'.
  54.  
  55. 
  56. File: scm.info,  Node: Improvements To Make,  Next: Finishing Dynamic Linking,  Prev: Operations,  Up: Internals
  57.  
  58. Improvements To Make
  59. ====================
  60.  
  61.    * Prefix and make more uniform all C function, variable, and constant
  62.      names.  Provide a file full of #define's to provide backward
  63.      compatability.
  64.  
  65.    * `lgcd()' *needs* to generate at most one bignum, but currently
  66.      generates more.
  67.  
  68.    * `divide()' could use shifts instead of multiply and divide when
  69.      scaling.
  70.  
  71.    * If an open fails because there are no unused file handles, GC
  72.      should be done so that file handles which are no longer used can be
  73.      collected.
  74.  
  75.    * If the symhash array is specially marked in garbage collection,
  76.      msymbols with value `UNDEFINED' which have no pointers to them can
  77.      be collected.  In Maclisp this was called `gctwa'.
  78.  
  79.    * Compaction could be done to `malloc'ed objects by freeing and
  80.      reallocing all the malloc objects encountered in a scan of the
  81.      heap.  Whether compactions would actually occur is system
  82.      depenedent.
  83.  
  84.    * Copying all of the stack is wasteful of storage.  Any time a
  85.      call-with-current-continuation is called the stack could be
  86.      re-rooted with a frame which calls the contin just created.  This
  87.      in combination with checking stack depth could also be used to
  88.      allow stacks deeper than 64K on the IBM PC.
  89.  
  90.    * lookupcar in `eval.c' should *not* memoize (to `ILOC's) when it
  91.      retrieves environments deeper or longer than 4095.  The values can
  92.      still be retrieved (albeit slowly), but an `ILOC' should not be
  93.      made.  The `MEMOIZE_LOCALS' flag could then be flushed.
  94.  
  95.    * The `must-' or `make-' routines need some sort of C macros or
  96.      conditionalization so that they check:
  97.  
  98.         * that the `LENGTH' field fits into a `size_t' (as is checked
  99.           now) for platforms with `(sizeof(size_t) < sizeof(SCM))'.
  100.  
  101.         * that the `LENGTH' field fits into 24 (or 56) bits on machines
  102.           where `size_t' is 32 bits or more.
  103.  
  104.      This is trickier than it first looks because the must_malloc()
  105.      routine is also used for allocating heap segments, which do not
  106.      have the `LENGTH' field restriction.  Putting the 24 bit test into
  107.      `must_malloc()' should be tested for speed impact.
  108.  
  109. 
  110. File: scm.info,  Node: Finishing Dynamic Linking,  Prev: Improvements To Make,  Up: Internals
  111.  
  112. Finishing Dynamic Linking
  113. =========================
  114.  
  115. Scott Schwartz <schwartz@galapagos.cse.psu.edu> suggests: One way to
  116. tidy up the dynamic loading stuff would be to grab the code from perl5.
  117.  
  118. VMS
  119. ...
  120.  
  121. George Carrette (gjc@mitech.com) outlines how to dynamically link on
  122. VMS.  There is already some code in `dynl.c' to do this, but someone
  123. with a VMS system needs to finish and debug it.
  124.  
  125.   1. Say you have this `main.c' program:
  126.  
  127.      main()
  128.      {init_lisp();
  129.       lisp_repl();}
  130.  
  131.   2. and you have your lisp in files `repl.c', `gc.c', `eval.c' and
  132.      there are some toplevel non-static variables in use called
  133.      `the_heap', `the_environment', and some read-only toplevel
  134.      structures, such as `the_subr_table'.
  135.  
  136.      $ LINK/SHARE=LISPRTL.EXE/DEBUG REPL.OBJ,GC.OBJ,EVAL.OBJ,LISPRTL.OPT/OPT
  137.  
  138.   3. where `LISPRTL.OPT' must contain at least this:
  139.  
  140.      SYS$LIBRARY:VAXCRTL/SHARE
  141.      UNIVERSAL=init_lisp
  142.      UNIVERSAL=lisp_repl
  143.      PSECT_ATTR=the_subr_table,SHR,NOWRT,LCL
  144.      PSECT_ATTR=the_heap,NOSHR,LCL
  145.      PSECT_ATTR=the_environment,NOSHR,LCL
  146.  
  147.      *Notice:* The "psect" (Program Section) attributes.
  148.     `LCL'
  149.           means to keep the name local to the shared library.  You
  150.           almost always want to do that for a good clean library.
  151.  
  152.     `SHR,NOWRT'
  153.           means shared-read-only.  Which is the default for code, and
  154.           is also good for efficiency of some data structures.
  155.  
  156.     `NOSHR,LCL'
  157.           is what you want for everything else.
  158.  
  159.      Note: If you do not have a handy list of all these toplevel
  160.      variables, do not dispair.  Just do your link with the
  161.      /MAP=LISPRTL.MAP/FULL and then search the map file,
  162.  
  163.      $SEARCH/OUT=LISPRTL.LOSERS LISPRTL.MAP  ",  SHR,NOEXE,  RD,  WRT"
  164.  
  165.      And use an emacs keyboard macro to muck the result into the proper
  166.      form.  Of course only the programmer can tell if things can be
  167.      made read-only.  I have a DCL command procedure to do this if you
  168.      want it.
  169.  
  170.   4.  Now MAIN.EXE would be linked thusly:
  171.  
  172.      $ DEFINE LISPRTL USER$DISK:[JAFFER]LISPRTL.EXE
  173.      
  174.      $LINK MAIN.OBJ,SYS$INPUT:/OPT
  175.       SYS$LIBRARY:VAXCRTL/SHARE
  176.       LISPRTL/SHARE
  177.  
  178.      Note the definition of the `LISPRTL' logical name.  Without such a
  179.      definition you will need to copy `LISPRTL.EXE' over to
  180.      `SYS$SHARE:' (aka `SYS$LIBRARY:') in order to invoke the main
  181.      program once it is linked.
  182.  
  183.   5. Now say you have a file of optional subrs, `MYSUBRS.C'.  And there
  184.      is a routine `INIT_MYSUBRS' that must be called before using it.
  185.  
  186.      $ CC MYSUBRS.C
  187.      $ LINK/SHARE=MYSUBRS.EXE MYSUBRS.OBJ,SYS$INPUT:/OPT
  188.        SYS$LIBRARY:VAXCRTL/SHARE
  189.        LISPRTL/SHARE
  190.        UNIVERSAL=INIT_MYSUBRS
  191.  
  192.      Ok.  Another hint is that you can avoid having to add the `PSECT'
  193.      declaration of `NOSHR,LCL' by declaring variables `status' in the
  194.      C language source.  That works great for most things.
  195.  
  196.   6. Then the dynamic loader would have to do this:
  197.  
  198.      {void (*init_fcn)();
  199.       long retval;
  200.       retval = lib$find_image_symbol("MYSUBRS","INIT_MYSUBRS",&init_fcn,
  201.                                      "SYS$DISK:[].EXE");
  202.       if (retval != SS$_NORMAL) error(...);
  203.       (*init_fcn)();}
  204.  
  205.      But of course all string arguments must be `(struct dsc$descriptor
  206.      *)' and the last argument is optional if `MYSUBRS' is defined as a
  207.      logical name or if `MYSUBRS.EXE' has been copied over to
  208.      `SYS$SHARE'.  The other consideration is that you will want to turn
  209.      off C-c or other interrupt handling while you are inside most
  210.      `lib$' calls.
  211.  
  212.      As far as the generation of all the `UNIVERSAL=...' declarations.
  213.      Well, you could do well to have that automatically generated from
  214.      the public `LISPRTL.H' file, of course.
  215.  
  216.      VMS has a good manual called the `Guide to Writing Modular
  217.      Procedures' or something like that, which covers this whole area
  218.      rather well, and also talks about advanced techniques, such as a
  219.      way to declare a program section with a pointer to a procedure
  220.      that will be automatically invoked whenever any shared image is
  221.      dynamically activated.  Also, how to set up a handler for normal
  222.      or abnormal program exit so that you can clean up side effects
  223.      (such as opening a database).  But for use with `LISPRTL' you
  224.      probably don't need that hair.
  225.  
  226.      One fancier option that is useful under VMS for `LISPLIB.EXE' is to
  227.      define all your exported procedures through an "call vector"
  228.      instead of having them just be pointers into random places in the
  229.      image, which is what you get by using `UNIVERSAL'.
  230.  
  231.      If you set up the call vector thing correctly it will allow you to
  232.      modify and relink `LISPLIB.EXE' without having to relink programs
  233.      that have been linked against it.
  234.  
  235. Windows NT
  236. ..........
  237.  
  238. George Carrette (gjc@mitech.com) outlines how to dynamically link on
  239. Windows NT:
  240.  
  241.    * The Software Developers Kit has a sample called SIMPLDLL.  Here is
  242.      the gist of it, following along the lines of the VMS description
  243.      above (contents of a makefile for the SDK NMAKE)
  244.  
  245.      LISPLIB.exp:
  246.      LISPLIB.lib: LISPLIB.def
  247.          $(implib) -machine:$(CPU) -def:LISPLIB.def -out:LISPLIB.lib
  248.      
  249.      LISPLIB.DLL : $(LISPLIB_OBJS) LISPLIB.EXP
  250.          $(link) $(linkdebug)              \
  251.          -dll                 \
  252.          -out:LISPLIB.DLL     \
  253.          LISPLIB.EXP $(LISPLIB_OBJS) $(conlibsdll)
  254.  
  255.    * The `LISPDEF.DEF' file has this:
  256.  
  257.      LIBRARY lisplib
  258.      EXPORT
  259.       init_lisp
  260.       init_repl
  261.  
  262.    * And `MAIN.EXE' using:
  263.  
  264.      CLINK = $(link) $(ldebug) $(conflags) -out:$*.exe $** $(conlibsdll)
  265.      
  266.      MAIN.EXE : MAIN.OBJ LISPLIB.LIB
  267.       $(CLINK)
  268.  
  269.    * And `MYSUBRS.DLL' is produced using:
  270.  
  271.      mysubrs.exp:
  272.      mysubrs.lib: mysubrs.def
  273.          $(implib) -machine:$(CPU) -def:MYSUBRS.def -out:MYSUBRS.lib
  274.      
  275.      mysubrs.dll : mysubrs.obj mysubrs.exp mysubrs.lib
  276.          $(link) $(linkdebug) \
  277.          -dll                 \
  278.          -out:mysubrs.dll     \
  279.          MYSUBRS.OBJ MYSUBRS.EXP LISPLIB.LIB $(conlibsdll)
  280.  
  281.    * Where `MYSUBRS.DEF' has
  282.  
  283.      LIBRARY mysubrs
  284.      EXPORT
  285.       INIT_MYSUBRS
  286.  
  287.    * And the dynamic loader looks something like this, calling the two
  288.      procedures `LoadLibrary' and `GetProcAddress'.
  289.  
  290.      LISP share_image_load(LISP fname)
  291.      {long iflag;
  292.       LISP retval,(*fcn)(void);
  293.       HANDLE hLib;
  294.       DWORD err;
  295.       char *libname,fcnname[64];
  296.       iflag = nointerrupt(1);
  297.       libname = c_string(fname);
  298.       _snprintf(fcnname,sizeof(fcnname),"INIT_%s",libname);
  299.       if (!(hLib = LoadLibrary(libname)))
  300.         {err = GetLastError();
  301.          retval = list2(fname,LSPNUM(err));
  302.          serror1("library failed to load",retval);}
  303.       if (!(fcn = (LISP (*)(void)) GetProcAddress(hLib,fcnname)))
  304.         {err = GetLastError();
  305.          retval = list2(fname,LSPNUM(err));
  306.          serror1("could not find library init procedure",retval);}
  307.       retval = (*fcn)();
  308.       nointerrupt(iflag);
  309.       return(retval);}
  310.  
  311.    * *Note:* in VMS the linker and dynamic loader is case sensitive, but
  312.      all the language compilers, including C, will by default upper-case
  313.      external symbols for use by the linker, although the debugger gets
  314.      its own symbols and case sensitivity is language mode dependant.
  315.      In Windows NT things are case sensitive generally except for file
  316.      and device names, which are case canonicalizing like in the
  317.      Symbolics filesystem.
  318.  
  319.    * *Also:* All this WINDOWS NT stuff will work in MS-DOS MS-Windows
  320.      3.1 too, by a method of compiling and linking under Windows NT,
  321.      and then copying various files over to MS-DOS/WINDOWS.
  322.  
  323. 
  324. File: scm.info,  Node: Procedure and Macro Index,  Next: Variable Index,  Prev: Internals,  Up: Top
  325.  
  326. Procedure and Macro Index
  327. *************************
  328.  
  329.   This is an alphabetical list of all the procedures and macros in SCM.
  330.  
  331. * Menu:
  332.  
  333. * #!:                                   Syntax Extensions.
  334. * #':                                   Syntax Extensions.
  335. * #+:                                   Syntax Extensions.
  336. * #-:                                   Syntax Extensions.
  337. * #.:                                   Syntax Extensions.
  338. * #|:                                   Syntax Extensions.
  339. * $abs:                                 Numeric.
  340. * $acos:                                Numeric.
  341. * $acosh:                               Numeric.
  342. * $asin:                                Numeric.
  343. * $asinh:                               Numeric.
  344. * $atan:                                Numeric.
  345. * $atan2:                               Numeric.
  346. * $atanh:                               Numeric.
  347. * $cos:                                 Numeric.
  348. * $cosh:                                Numeric.
  349. * $exp:                                 Numeric.
  350. * $expt:                                Numeric.
  351. * $log:                                 Numeric.
  352. * $sin:                                 Numeric.
  353. * $sinh:                                Numeric.
  354. * $sqrt:                                Numeric.
  355. * $tan:                                 Numeric.
  356. * $tanh:                                Numeric.
  357. * -:                                    SCM Options.
  358. * -:                                    SCM Options.
  359. * -a:                                   SCM Options.
  360. * -b:                                   SCM Options.
  361. * -c:                                   SCM Options.
  362. * -e:                                   SCM Options.
  363. * -f:                                   SCM Options.
  364. * -i:                                   SCM Options.
  365. * -l:                                   SCM Options.
  366. * -m:                                   SCM Options.
  367. * -no-init-file:                        SCM Options.
  368. * -p:                                   SCM Options.
  369. * -q:                                   SCM Options.
  370. * -r:                                   SCM Options.
  371. * -s:                                   SCM Options.
  372. * -u:                                   SCM Options.
  373. * -v:                                   SCM Options.
  374. * @apply:                               Low Level Syntactic Hooks.
  375. * @call-with-current-continuation:      Low Level Syntactic Hooks.
  376. * abort:                                Internal State.
  377. * access:                               I/O-Extensions.
  378. * acct:                                 Posix Extensions.
  379. * acons:                                Miscellaneous Procedures.
  380. * acosh:                                Numeric.
  381. * alarm:                                Interrupts.
  382. * alarm-interrupt:                      Interrupts.
  383. * ALLOW_INTS:                           Signals.
  384. * alrm_signal:                          Signals.
  385. * arithmetic-error:                     Interrupts.
  386. * array->list:                          Conventional Arrays.
  387. * array-contents:                       Conventional Arrays.
  388. * array-contents:                       Conventional Arrays.
  389. * array-copy!:                          Conventional Arrays.
  390. * array-dimensions:                     Conventional Arrays.
  391. * array-equal?:                         Conventional Arrays.
  392. * array-fill!:                          Conventional Arrays.
  393. * array-for-each:                       Array Mapping.
  394. * array-in-bounds?:                     Conventional Arrays.
  395. * array-index-map!:                     Array Mapping.
  396. * array-map!:                           Array Mapping.
  397. * array-prototype:                      Uniform Array.
  398. * array-rank:                           Conventional Arrays.
  399. * array-ref:                            Conventional Arrays.
  400. * array-set!:                           Conventional Arrays.
  401. * array-shape:                          Conventional Arrays.
  402. * array?:                               Uniform Array.
  403. * array?:                               Conventional Arrays.
  404. * asinh:                                Numeric.
  405. * ASRTGO:                               C Macros.
  406. * ASSERT:                               C Macros.
  407. * atanh:                                Numeric.
  408. * bg-pipe:                              Gscsh.
  409. * bit-count:                            Bit Vectors.
  410. * bit-count*:                           Bit Vectors.
  411. * bit-invert!:                          Bit Vectors.
  412. * bit-position:                         Bit Vectors.
  413. * bit-set*!:                            Bit Vectors.
  414. * box:                                  Curses Miscellany.
  415. * builtin-variable:                     Variables.
  416. * call-with-dynamic-root:               Dynamic Roots.
  417. * CAR:                                  Cells.
  418. * catch:                                Exceptions.
  419. * cbreak:                               Terminal Mode Setting.
  420. * CDR:                                  Cells.
  421. * CHARS:                                Cells.
  422. * CHARS:                                Cells.
  423. * chdir:                                I/O-Extensions.
  424. * chmod:                                I/O-Extensions.
  425. * chown:                                Posix Extensions.
  426. * clearok:                              Output Options Setting.
  427. * close-io-port:                        Files and Ports.
  428. * close-port:                           Window Manipulation.
  429. * close-port:                           Posix Extensions.
  430. * close-port:                           Files and Ports.
  431. * closedir:                             I/O-Extensions.
  432. * CLOSEDP:                              Cells.
  433. * CLOSUREP:                             Cells.
  434. * CODE:                                 Cells.
  435. * compile-file:                         Compiling And Linking.
  436. * CONSP:                                Cells.
  437. * copy-tree:                            Miscellaneous Procedures.
  438. * cosh:                                 Numeric.
  439. * could-not-open:                       Interrupts.
  440. * current-error-port:                   Files and Ports.
  441. * current-time:                         Time.
  442. * default-input-port:                   Line Editing.
  443. * default-output-port:                  Line Editing.
  444. * DEFER_INTS:                           Signals.
  445. * defined?:                             Syntax Extensions.
  446. * defvar:                               Syntax Extensions.
  447. * dimensions->uniform-array:            Uniform Array.
  448. * dimensions->uniform-array:            Uniform Array.
  449. * display:                              Output.
  450. * display:                              Output.
  451. * duplicate-port:                       I/O-Extensions.
  452. * dyn:call:                             Compiling And Linking.
  453. * dyn:link:                             Compiling And Linking.
  454. * dyn:unlink:                           Compiling And Linking.
  455. * dynamic-root:                         Dynamic Roots.
  456. * echo:                                 Terminal Mode Setting.
  457. * ed:                                   System Interface.
  458. * ed:                                   System Interface.
  459. * enclose-array:                        Conventional Arrays.
  460. * end-of-program:                       Interrupts.
  461. * endwin:                               Curses.
  462. * ENV:                                  Cells.
  463. * equal-fn?:                            Key-Vector 0 Elements.
  464. * errno:                                System Interface.
  465. * errno:                                System Interface.
  466. * error:                                Internal State.
  467. * eval:                                 Evaluation.
  468. * EVAL:                                 Evaluation.
  469. * eval:                                 Miscellaneous Procedures.
  470. * eval-string:                          Miscellaneous Procedures.
  471. * eval2:                                User Defined Top Levels.
  472. * exec-pipe:                            Gscsh.
  473. * execl:                                I/O-Extensions.
  474. * execlp:                               I/O-Extensions.
  475. * execv:                                I/O-Extensions.
  476. * execvp:                               I/O-Extensions.
  477. * exit:                                 System Interface.
  478. * exit:                                 System Interface.
  479. * fg-pipe:                              Gscsh.
  480. * file-position:                        I/O-Extensions.
  481. * file-set-position:                    I/O-Extensions.
  482. * fileno:                               I/O-Extensions.
  483. * force-output:                         Window Manipulation.
  484. * fork:                                 Gscsh.
  485. * fork:                                 Gscsh.
  486. * fork:                                 Posix Extensions.
  487. * FPORTP:                               Cells.
  488. * gc:                                   Internal State.
  489. * get-internal-real-time:               Time.
  490. * get-internal-run-time:                Time.
  491. * getcwd:                               I/O-Extensions.
  492. * getegid:                              Posix Extensions.
  493. * geteuid:                              Posix Extensions.
  494. * getgid:                               Posix Extensions.
  495. * getgr:                                Posix Extensions.
  496. * getgr:                                Posix Extensions.
  497. * getgr:                                Posix Extensions.
  498. * getgroups:                            Posix Extensions.
  499. * gethost:                              Host Data.
  500. * gethost:                              Host Data.
  501. * getnet:                               Host Data.
  502. * getnet:                               Host Data.
  503. * getpeername:                          Socket.
  504. * getpid:                               I/O-Extensions.
  505. * getppid:                              Posix Extensions.
  506. * getproto:                             Host Data.
  507. * getproto:                             Host Data.
  508. * getpw:                                Posix Extensions.
  509. * getpw:                                Posix Extensions.
  510. * getpw:                                Posix Extensions.
  511. * getserv:                              Host Data.
  512. * getserv:                              Host Data.
  513. * getsockname:                          Socket.
  514. * getuid:                               Posix Extensions.
  515. * getyx:                                Input.
  516. * hang-up:                              Interrupts.
  517. * ICHR:                                 Immediates.
  518. * ICHRP:                                Immediates.
  519. * idlok:                                Output Options Setting.
  520. * IFLAGP:                               Immediates.
  521. * IMP:                                  Immediates.
  522. * inet:address->string:                 Internet Addresses.
  523. * inet:local-network-address:           Internet Addresses.
  524. * inet:make-address:                    Internet Addresses.
  525. * inet:network:                         Internet Addresses.
  526. * inet:string->address:                 Internet Addresses.
  527. * initscr:                              Curses.
  528. * init_signals:                         Signals.
  529. * INPORTP:                              Cells.
  530. * intern-string:                        Obarrays.
  531. * intern-symbol:                        Obarrays.
  532. * int_signal:                           Signals.
  533. * INUM:                                 Immediates.
  534. * INUMP:                                Immediates.
  535. * isa-fn?:                              Key-Vector 0 Elements.
  536. * isatty?:                              I/O-Extensions.
  537. * ISYMCHARS:                            Immediates.
  538. * ISYMNUM:                              Immediates.
  539. * ISYMP:                                Immediates.
  540. * keyword->symbol:                      Keywords.
  541. * keyword?:                             Keywords.
  542. * kill:                                 Posix Extensions.
  543. * leaveok:                              Output Options Setting.
  544. * LENGTH:                               Cells.
  545. * LENGTH:                               Cells.
  546. * LENGTH:                               Cells.
  547. * line-editing:                         Line Editing.
  548. * line-editing:                         Line Editing.
  549. * line-number:                          Miscellaneous Procedures.
  550. * link:                                 Posix Extensions.
  551. * link-named-scm:                       Compiling And Linking.
  552. * list->uniform-array:                  Uniform Array.
  553. * list->uniform-vector:                 Uniform Array.
  554. * list-file:                            Miscellaneous Procedures.
  555. * load:                                 Compiling And Linking.
  556. * load-string:                          Miscellaneous Procedures.
  557. * lock-vector!:                         Lvector Procedures.
  558. * lstat:                                Posix Extensions.
  559. * lvector-accessor:                     Lvector Procedures.
  560. * lvector-isa?:                         Lvector Procedures.
  561. * lvector-keys:                         Lvector Procedures.
  562. * lvector-modifier:                     Lvector Procedures.
  563. * lvector-ref:                          Lvector Procedures.
  564. * lvector-set!:                         Lvector Procedures.
  565. * lvector?:                             Lvector Procedures.
  566. * makcclo:                              Cells.
  567. * make-arbiter:                         Process Synchronization.
  568. * make-array:                           Conventional Arrays.
  569. * make-edited-line-port:                Line Editing.
  570. * make-keyword:                         Keywords.
  571. * make-shared-array:                    Conventional Arrays.
  572. * make-soft-port:                       Soft Ports.
  573. * make-stream-socket:                   Socket.
  574. * make-stream-socket:                   Socket.
  575. * make-stream-socketpair:               Socket.
  576. * make-stream-socketpair:               Socket.
  577. * make-undefined:                       Variables.
  578. * make-undefined:                       Variables.
  579. * make-uniform-array:                   Uniform Array.
  580. * make-uniform-vector:                  Uniform Array.
  581. * make-uniform-vector:                  Uniform Array.
  582. * make-variable:                        Variables.
  583. * make-variable:                        Variables.
  584. * make_gsubr:                           Defining Subrs.
  585. * MAKICHR:                              Immediates.
  586. * MAKIFLAG:                             Immediates.
  587. * MAKINUM:                              Immediates.
  588. * MAKISYM:                              Immediates.
  589. * MAKSPCSYM:                            Immediates.
  590. * mkdir:                                I/O-Extensions.
  591. * mknod:                                Posix Extensions.
  592. * mvwin:                                Window Manipulation.
  593. * NCONSP:                               Cells.
  594. * NEWCELL:                              Cells.
  595. * newwin:                               Window Manipulation.
  596. * nice:                                 Posix Extensions.
  597. * NIMP:                                 Immediates.
  598. * NINUMP:                               Immediates.
  599. * nl:                                   Terminal Mode Setting.
  600. * nocbreak:                             Terminal Mode Setting.
  601. * nodelay:                              Output Options Setting.
  602. * noecho:                               Terminal Mode Setting.
  603. * nonl:                                 Terminal Mode Setting.
  604. * noraw:                                Terminal Mode Setting.
  605. * NSTRINGP:                             Cells.
  606. * NVECTORP:                             Cells.
  607. * open-file:                            Files and Ports.
  608. * open-input-pipe:                      Posix Extensions.
  609. * open-io-file:                         Files and Ports.
  610. * open-output-pipe:                     Posix Extensions.
  611. * open-pipe:                            Posix Extensions.
  612. * opendir:                              I/O-Extensions.
  613. * OPENP:                                Cells.
  614. * OPFPORTP:                             Cells.
  615. * OPINFPORTP:                           Cells.
  616. * OPINPORTP:                            Cells.
  617. * OPOUTFPORTP:                          Cells.
  618. * OPOUTPORTP:                           Cells.
  619. * OPPORTP:                              Cells.
  620. * out-of-storage:                       Interrupts.
  621. * OUTPORTP:                             Cells.
  622. * overlay:                              Window Manipulation.
  623. * overwrite:                            Window Manipulation.
  624. * perror:                               System Interface.
  625. * pipe:                                 Posix Extensions.
  626. * PORTP:                                Cells.
  627. * print-fn:                             Key-Vector 0 Elements.
  628. * proc:                                 Gwish.
  629. * procedure->macro:                     Low Level Syntactic Hooks.
  630. * procedure->memoizing-macro:           Low Level Syntactic Hooks.
  631. * procedure->syntax:                    Low Level Syntactic Hooks.
  632. * procedure-assoc:                      Procedure Properties.
  633. * procedure-properties:                 Procedure Properties.
  634. * procedure-property:                   Procedure Properties.
  635. * procedure-putprop!:                   Procedure Properties.
  636. * program-arguments:                    System Interface.
  637. * putenv:                               I/O-Extensions.
  638. * quit:                                 System Interface.
  639. * quit:                                 System Interface.
  640. * raw:                                  Terminal Mode Setting.
  641. * read-char:                            Input.
  642. * read:sharp:                           Low Level Syntactic Hooks.
  643. * readdir:                              I/O-Extensions.
  644. * readlink:                             Posix Extensions.
  645. * redirect-port!:                       I/O-Extensions.
  646. * ref-fn:                               Key-Vector 0 Elements.
  647. * refresh:                              Window Manipulation.
  648. * regcomp:                              Regular Expression Pattern Matching.
  649. * regerror:                             Regular Expression Pattern Matching.
  650. * regexec:                              Regular Expression Pattern Matching.
  651. * regmatch:                             Regular Expression Pattern Matching.
  652. * regmatch?:                            Regular Expression Pattern Matching.
  653. * regmatchv:                            Regular Expression Pattern Matching.
  654. * regsearch:                            Regular Expression Pattern Matching.
  655. * regsearchv:                           Regular Expression Pattern Matching.
  656. * release-arbiter:                      Process Synchronization.
  657. * rename-file:                          I/O-Extensions.
  658. * reopen-file:                          I/O-Extensions.
  659. * require:                              Compiling And Linking.
  660. * require:                              Compiling And Linking.
  661. * resetty:                              Terminal Mode Setting.
  662. * rewinddir:                            I/O-Extensions.
  663. * rmdir:                                I/O-Extensions.
  664. * room:                                 Internal State.
  665. * room:                                 Internal State.
  666. * savetty:                              Terminal Mode Setting.
  667. * scm_evstr:                            Calling Scheme From C.
  668. * scm_ldfile:                           Calling Scheme From C.
  669. * scm_ldprog:                           Calling Scheme From C.
  670. * scm_ldstr:                            Calling Scheme From C.
  671. * scroll:                               Output.
  672. * scrollok:                             Output Options Setting.
  673. * serial-array-copy!:                   Conventional Arrays.
  674. * serial-array-map!:                    Array Mapping.
  675. * set-fn:                               Key-Vector 0 Elements.
  676. * set-procedure-properties!:            Procedure Properties.
  677. * setegid:                              Posix Extensions.
  678. * seteuid:                              Posix Extensions.
  679. * setgid:                               Posix Extensions.
  680. * setgrent:                             Posix Extensions.
  681. * setgrent:                             Posix Extensions.
  682. * setgrent:                             Posix Extensions.
  683. * sethostent:                           Host Data.
  684. * sethostent:                           Host Data.
  685. * setnetent:                            Host Data.
  686. * setnetent:                            Host Data.
  687. * setprotoent:                          Host Data.
  688. * setprotoent:                          Host Data.
  689. * setpwent:                             Posix Extensions.
  690. * setpwent:                             Posix Extensions.
  691. * setpwent:                             Posix Extensions.
  692. * setservent:                           Host Data.
  693. * setservent:                           Host Data.
  694. * setuid:                               Posix Extensions.
  695. * SIDEVAL:                              Evaluation.
  696. * sinh:                                 Numeric.
  697. * socket-name:address:                  Socket.
  698. * socket-name:family:                   Socket.
  699. * socket-name:port-number:              Socket.
  700. * socket:accept:                        Socket.
  701. * socket:bind:                          Socket.
  702. * socket:bind:                          Socket.
  703. * socket:connect:                       Socket.
  704. * socket:connect:                       Socket.
  705. * socket:listen:                        Socket.
  706. * socket:shutdown:                      Socket.
  707. * stat:                                 I/O-Extensions.
  708. * STREAM:                               Cells.
  709. * string-edit:                          Regular Expression Pattern Matching.
  710. * string-split:                         Regular Expression Pattern Matching.
  711. * string-splitv:                        Regular Expression Pattern Matching.
  712. * STRINGP:                              Cells.
  713. * subwin:                               Window Manipulation.
  714. * symbol-binding:                       Obarrays.
  715. * symbol-bound?:                        Obarrays.
  716. * symbol-interned?:                     Obarrays.
  717. * symbol-set!:                          Obarrays.
  718. * SYMBOLP:                              Cells.
  719. * symlink:                              Posix Extensions.
  720. * sync:                                 Posix Extensions.
  721. * tanh:                                 Numeric.
  722. * tcl-apply-command:                    Tcl Facilities.
  723. * tcl-command:                          Tcl Facilities.
  724. * tcl-create-command:                   Tcl Facilities.
  725. * tcl-create-interp:                    Tcl Facilities.
  726. * tcl-delete-command:                   Tcl Facilities.
  727. * tcl-get-boolean:                      Tcl Facilities.
  728. * tcl-get-double:                       Tcl Facilities.
  729. * tcl-get-int:                          Tcl Facilities.
  730. * tcl-get-var2:                         Tcl Facilities.
  731. * tcl-global-eval:                      Tcl Facilities.
  732. * tcl-lambda:                           Gwish.
  733. * tcl-merge:                            Tcl Facilities.
  734. * tcl-set-var2:                         Tcl Facilities.
  735. * tcl-split-list:                       Tcl Facilities.
  736. * tcl-trace-var2:                       Tcl Facilities.
  737. * tcl-untrace-var2:                     Tcl Facilities.
  738. * terms:                                Miscellaneous Procedures.
  739. * throw:                                Exceptions.
  740. * throw:                                Exceptions.
  741. * ticks:                                Interrupts.
  742. * ticks-interrupt:                      Interrupts.
  743. * tk-do-one-event:                      Tk Facilities.
  744. * tk-init-main-window:                  Tk Facilities.
  745. * tk-main-loop:                         Tk Facilities.
  746. * touchline:                            Window Manipulation.
  747. * touchwin:                             Window Manipulation.
  748. * transpose-array:                      Conventional Arrays.
  749. * try-arbiter:                          Process Synchronization.
  750. * try-load:                             Miscellaneous Procedures.
  751. * ttyname:                              Posix Extensions.
  752. * TYP16:                                Cells.
  753. * TYP3:                                 Cells.
  754. * TYP7:                                 Cells.
  755. * UCHARS:                               Cells.
  756. * UCHARS:                               Cells.
  757. * umask:                                I/O-Extensions.
  758. * uname:                                Posix Extensions.
  759. * unctrl:                               Curses Miscellany.
  760. * uniform-array-read!:                  Uniform Array.
  761. * uniform-array-read!:                  Uniform Array.
  762. * uniform-array-write:                  Uniform Array.
  763. * uniform-array-write:                  Uniform Array.
  764. * uniform-vector-fill!:                 Uniform Array.
  765. * uniform-vector-length:                Uniform Array.
  766. * uniform-vector-read!:                 Uniform Array.
  767. * uniform-vector-read!:                 Uniform Array.
  768. * uniform-vector-write:                 Uniform Array.
  769. * uniform-vector-write:                 Uniform Array.
  770. * unlock-vector!:                       Lvector Procedures.
  771. * user-interrupt:                       Interrupts.
  772. * usr:lib:                              Compiling And Linking.
  773. * utime:                                I/O-Extensions.
  774. * variable-bound?:                      Variables.
  775. * variable-ref:                         Variables.
  776. * variable-set!:                        Variables.
  777. * variable?:                            Variables.
  778. * vector-set-length!:                   Miscellaneous Procedures.
  779. * VECTORP:                              Cells.
  780. * VELTS:                                Cells.
  781. * verbose:                              Internal State.
  782. * vms-debug:                            System Interface.
  783. * wadd:                                 Output.
  784. * wadd:                                 Output.
  785. * wait:                                 Gscsh.
  786. * wait:                                 Gscsh.
  787. * wait:                                 Gscsh.
  788. * waitpid:                              Posix Extensions.
  789. * wclear:                               Output.
  790. * wclrtobot:                            Output.
  791. * wclrtoeol:                            Output.
  792. * wdelch:                               Output.
  793. * wdeleteln:                            Output.
  794. * werase:                               Output.
  795. * winch:                                Input.
  796. * winsch:                               Output.
  797. * winsertln:                            Output.
  798. * with-error-to-file:                   Files and Ports.
  799. * with-error-to-port:                   Files and Ports.
  800. * with-input-from-port:                 Files and Ports.
  801. * with-output-to-port:                  Files and Ports.
  802. * wmove:                                Window Manipulation.
  803. * wstandend:                            Curses Miscellany.
  804. * wstandout:                            Curses Miscellany.
  805. * _ionbf:                               Files and Ports.
  806.  
  807. 
  808. File: scm.info,  Node: Variable Index,  Next: Type Index,  Prev: Procedure and Macro Index,  Up: Top
  809.  
  810. Variable Index
  811. **************
  812.  
  813.   This is an alphabetical list of all the global variables in SCM.
  814.  
  815. * Menu:
  816.  
  817. * *argv*:                               SCM Variables.
  818. * *interactive*:                        SCM Variables.
  819. * *load-pathname*:                      Miscellaneous Procedures.
  820. * *R4RS-macro*:                         SCM Variables.
  821. * *scm-version*:                        Internal State.
  822. * af_inet:                              Host Data.
  823. * af_unix:                              Host Data.
  824. * BOOL_F:                               Immediates.
  825. * BOOL_T:                               Immediates.
  826. * EOF_VAL:                              Immediates.
  827. * EOL:                                  Immediates.
  828. * errobj:                               Internal State.
  829. * HOME:                                 SCM Variables.
  830. * internal-time-units-per-second:       Time.
  831. * INUM0:                                Immediates.
  832. * isymnames:                            Immediates.
  833. * lvector-hook-slots:                   Key-Vector 0 Elements.
  834. * most-negative-fixnum:                 Numeric.
  835. * most-positive-fixnum:                 Numeric.
  836. * NUM_ISPCSYM:                          Immediates.
  837. * NUM_ISYMS:                            Immediates.
  838. * open_both:                            Files and Ports.
  839. * open_read:                            Files and Ports.
  840. * open_write:                           Files and Ports.
  841. * SCHEME_LIBRARY_PATH:                  SCM Variables.
  842. * SCM_INIT_PATH:                        SCM Variables.
  843. * symhash:                              Evaluation.
  844. * UNDEFINED:                            Immediates.
  845. * UNSPECIFIED:                          Immediates.
  846.  
  847. 
  848. File: scm.info,  Node: Type Index,  Prev: Variable Index,  Up: Top
  849.  
  850. Type Index
  851. **********
  852.  
  853.   This is an alphabetical list of all the data types in SCM.
  854.  
  855. * Menu:
  856.  
  857. * CELLPTR:                              Immediates.
  858. * GLOC:                                 Evaluation.
  859. * gloc:                                 Immediates.
  860. * ichr:                                 Immediates.
  861. * iflags:                               Immediates.
  862. * ILOC:                                 Evaluation.
  863. * iloc:                                 Immediates.
  864. * inum:                                 Immediates.
  865. * ispcsym:                              Immediates.
  866. * isym:                                 Immediates.
  867. * spare:                                Cells.
  868. * tc16_arbiter:                         Cells.
  869. * tc16_array:                           Cells.
  870. * tc16_bigneg:                          Cells.
  871. * tc16_bigpos:                          Cells.
  872. * tc16_flo:                             Cells.
  873. * tc16_inpipe:                          Cells.
  874. * tc16_inport:                          Cells.
  875. * tc16_ioport:                          Cells.
  876. * tc16_macro:                           Cells.
  877. * tc16_outpipe:                         Cells.
  878. * tc16_outport:                         Cells.
  879. * tc16_promise:                         Cells.
  880. * tc16_sfport:                          Cells.
  881. * tc16_strport:                         Cells.
  882. * tc3_closure:                          Cells.
  883. * tc3_cons:                             Cells.
  884. * tc7_asubr:                            Cells.
  885. * tc7_bvect:                            Cells.
  886. * tc7_cclo:                             Cells.
  887. * tc7_contin:                           Cells.
  888. * tc7_cvect:                            Cells.
  889. * tc7_cxr:                              Cells.
  890. * tc7_dvect:                            Cells.
  891. * tc7_fvect:                            Cells.
  892. * tc7_ivect:                            Cells.
  893. * tc7_lsubr:                            Cells.
  894. * tc7_lsubr_2:                          Cells.
  895. * tc7_msymbol:                          Cells.
  896. * tc7_rpsubr:                           Cells.
  897. * tc7_ssymbol:                          Cells.
  898. * tc7_string:                           Cells.
  899. * tc7_subr_0:                           Cells.
  900. * tc7_subr_1:                           Cells.
  901. * tc7_subr_1o:                          Cells.
  902. * tc7_subr_2:                           Cells.
  903. * tc7_subr_2o:                          Cells.
  904. * tc7_subr_3:                           Cells.
  905. * tc7_uvect:                            Cells.
  906. * tc7_vector:                           Cells.
  907. * tc_dblc:                              Cells.
  908. * tc_dblr:                              Cells.
  909. * tc_free_cell:                         Cells.
  910.  
  911.  
  912.